home *** CD-ROM | disk | FTP | other *** search
/ The Arsenal Files 8 / The Arsenal Files Collection #8 (Arsenal Computer) (1996).ISO / prg_casm / snipview.zip / VIDMGR.C < prev    next >
C/C++ Source or Header  |  1996-07-11  |  6KB  |  217 lines
  1. /*
  2.  *  VIDMGR.C; Screen drawing, cursor and keyboard routines for text mode
  3.  *            16-bit and 32-bit MS-DOS, 16-bit and 32-bit OS/2, and 32-bit
  4.  *            Windows 95/NT applications.  Release 1.2.
  5.  *
  6.  *  This module written in March 1996 by Andrew Clarke and released to the
  7.  *  public domain.  Last modified in June 1996.
  8.  *
  9.  *  VidMgr has been compiled and tested with the following C compilers:
  10.  *
  11.  *    - Borland C++ (16-bit) for DOS 3.1
  12.  *    - Borland C++ (16-bit) for DOS 4.5
  13.  *    - Borland C++ (32-bit) for OS/2 1.0
  14.  *    - Cygnus GNU C (32-bit) for Windows 95/NT b14.0
  15.  *    - DJGPP GNU C (32-bit) for DOS 2.0
  16.  *    - EMX GNU C (32-bit) for OS/2 & DOS 0.9b
  17.  *    - IBM VisualAge C/C++ 3.0 (32-bit) for OS/2
  18.  *    - Microsoft C/C++ (16-bit) for OS/2 6.00a
  19.  *    - Microsoft C/C++ (16-bit) for DOS 8.00c
  20.  *    - Microsoft Quick C (16-bit) for DOS 2.50
  21.  *    - Microsoft Visual C/C++ (16-bit) for DOS 1.52
  22.  *    - WATCOM C/C++ (16-bit & 32-bit) for DOS 9.5
  23.  *    - WATCOM C/C++ (16-bit & 32-bit) for DOS 10.0
  24.  *    - WATCOM C/C++ (32-bit) for OS/2 10.0
  25.  *    - WATCOM C/C++ (32-bit) for Windows 95/NT 10.0
  26.  *    - HI-TECH Pacific C (16-bit) for DOS 7.51
  27.  *    - Symantec C/C++ (16-bit) for DOS 7.0
  28.  *    - Zortech C/C++ (16-bit) for DOS 3.0r4
  29.  */
  30.  
  31. #include <stdio.h>
  32. #include <stdarg.h>
  33. #include <string.h>
  34. #include "vidmgr.h"
  35.  
  36. struct vm_info vm_startup;
  37. char vm_curattr;
  38.  
  39. char vm_frame_blank[] = "      ";
  40. char vm_frame_single[] = "┌─┐│└┘";
  41. char vm_frame_double[] = "╔═╗║╚╝";
  42.  
  43. void vm_setattr(char attr)
  44. {
  45.     vm_curattr = attr;
  46. }
  47.  
  48. void vm_printf(char x, char y, const char *format,...)
  49. {
  50.     va_list args;
  51.     char buffer[512];
  52.     va_start(args, format);
  53.     vsprintf(buffer, format, args);
  54.     va_end(args);
  55.     vm_puts(x, y, buffer);
  56. }
  57.  
  58. void vm_printfcenter(char row, const char *format,...)
  59. {
  60.     va_list args;
  61.     char buffer[512];
  62.     va_start(args, format);
  63.     vsprintf(buffer, format, args);
  64.     va_end(args);
  65.     vm_puts((char)((vm_getscreenwidth() / 2) - (strlen(buffer) / 2)), row, buffer);
  66. }
  67.  
  68. void vm_printfbetween(char x1, char x2, char row, const char *format,...)
  69. {
  70.     char x;
  71.     va_list args;
  72.     char buffer[512];
  73.     va_start(args, format);
  74.     vsprintf(buffer, format, args);
  75.     va_end(args);
  76.     if ((char)strlen(buffer) >= (char)(x2 - x1 + 1))
  77.     {
  78.         vm_puts(x1, row, buffer);
  79.     }
  80.     else
  81.     {
  82.         x = (char)(x1 + (x2 - x1 + 1 - strlen(buffer)) / 2);
  83.         vm_puts(x, row, buffer);
  84.     }
  85. }
  86.  
  87. void vm_xprintf(char x, char y, char attr, const char *format,...)
  88. {
  89.     va_list args;
  90.     char buffer[512];
  91.     va_start(args, format);
  92.     vsprintf(buffer, format, args);
  93.     va_end(args);
  94.     vm_xputs(x, y, attr, buffer);
  95. }
  96.  
  97. void vm_xprintfcenter(char row, char attr, const char *format,...)
  98. {
  99.     va_list args;
  100.     char buffer[512];
  101.     va_start(args, format);
  102.     vsprintf(buffer, format, args);
  103.     va_end(args);
  104.     vm_xputs((char)((vm_getscreenwidth() / 2) - (strlen(buffer) / 2)), row, attr, buffer);
  105. }
  106.  
  107. void vm_xprintfbetween(char x1, char x2, char row, char attr, const char *format,...)
  108. {
  109.     char x;
  110.     va_list args;
  111.     char buffer[512];
  112.     va_start(args, format);
  113.     vsprintf(buffer, format, args);
  114.     va_end(args);
  115.     if ((char)strlen(buffer) >= (char)(x2 - x1 + 1))
  116.     {
  117.         vm_xputs(x1, row, attr, buffer);
  118.     }
  119.     else
  120.     {
  121.         x = (char)(x1 + (x2 - x1 + 1 - strlen(buffer)) / 2);
  122.         vm_xputs(x, row, attr, buffer);
  123.     }
  124. }
  125.  
  126. void vm_paintclearscreen(char attr)
  127. {
  128.     vm_paintclearbox(1, 1, vm_getscreenwidth(), vm_getscreenheight(), attr);
  129. }
  130.  
  131. void vm_paintclearline(char row, char attr)
  132. {
  133.     vm_paintclearbox(1, row, vm_getscreenwidth(), row, attr);
  134. }
  135.  
  136. void vm_paintcleareol(char row, char attr)
  137. {
  138.     vm_paintclearbox(vm_wherex(), row, (char)(vm_getscreenwidth() - vm_wherex()), row, attr);
  139. }
  140.  
  141. void vm_paintscreen(char attr)
  142. {
  143.     vm_paintbox(1, 1, vm_getscreenwidth(), vm_getscreenheight(), attr);
  144. }
  145.  
  146. void vm_paintline(char row, char attr)
  147. {
  148.     vm_paintbox(1, row, vm_getscreenwidth(), row, attr);
  149. }
  150.  
  151. void vm_painteol(char row, char attr)
  152. {
  153.     vm_paintbox(vm_wherex(), row, (char)(vm_getscreenwidth() - vm_wherex()), row, attr);
  154. }
  155.  
  156. void vm_clearscreen(void)
  157. {
  158.     vm_clearbox(1, 1, vm_getscreenwidth(), vm_getscreenheight());
  159. }
  160.  
  161. void vm_clearline(char row)
  162. {
  163.     vm_clearbox(1, row, vm_getscreenwidth(), row);
  164. }
  165.  
  166. void vm_cleareol(char row)
  167. {
  168.     vm_clearbox(vm_wherex(), row, (char)(vm_getscreenwidth() - vm_wherex()), row);
  169. }
  170.  
  171. void vm_fillscreen(char ch)
  172. {
  173.     vm_fillbox(1, 1, vm_getscreenwidth(), vm_getscreenheight(), ch);
  174. }
  175.  
  176. void vm_fillline(char row, char ch)
  177. {
  178.     vm_fillbox(1, row, vm_getscreenwidth(), row, ch);
  179. }
  180.  
  181. void vm_filleol(char row, char ch)
  182. {
  183.     vm_fillbox(vm_wherex(), row, (char)(vm_getscreenwidth() - vm_wherex()), row, ch);
  184. }
  185.  
  186. void vm_clrscr(void)
  187. {
  188.     vm_paintclearscreen(vm_curattr);
  189.     vm_gotoxy(1, 1);
  190. }
  191.  
  192. void vm_clreol(void)
  193. {
  194.     vm_paintcleareol(vm_wherey(), vm_curattr);
  195. }
  196.  
  197. void vm_vertline(char y1, char y2, char col, char attr, char ch)
  198. {
  199.     char y;
  200.     for (y = y1; y <= y2; y++)
  201.     {
  202.         vm_xputch(col, y, attr, ch);
  203.     }
  204. }
  205.  
  206. void vm_frame(char x1, char y1, char x2, char y2, char attr, char *frame)
  207. {
  208.     vm_xputch(x1, y1, attr, frame[0]);
  209.     vm_horizline((char)(x1 + 1), (char)(x2 - 1), y1, attr, frame[1]);
  210.     vm_xputch(x2, y1, attr, frame[2]);
  211.     vm_vertline((char)(y1 + 1), (char)(y2 - 1), x1, attr, frame[3]);
  212.     vm_vertline((char)(y1 + 1), (char)(y2 - 1), x2, attr, frame[3]);
  213.     vm_xputch(x1, y2, attr, frame[4]);
  214.     vm_horizline((char)(x1 + 1), (char)(x2 - 1), y2, attr, frame[1]);
  215.     vm_xputch(x2, y2, attr, frame[5]);
  216. }
  217.